home *** CD-ROM | disk | FTP | other *** search
/ Magnum One / Magnum One (Mid-American Digital) (Disc Manufacturing).iso / d7 / lanuts.arc / FASTNET.C < prev    next >
Text File  |  1991-10-30  |  9KB  |  372 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #include <string.h>
  4. #include <dos.h>
  5. #include <malloc.h>
  6. #include <direct.h>
  7. #include <conio.h>
  8.  
  9. #include "lantasti.h"
  10. #include "lanctl.h"
  11.  
  12. #define LIST_SIZE 30
  13. #define NAME_SIZE 20
  14.            
  15. typedef struct FLAGS {
  16.         int suppress,
  17.             stop;
  18.          char fname[50];   
  19.          } FLAGS;
  20.  
  21. /* net commands supported by fastnet */
  22. #define NUM_NET_CMDS 5
  23. char *net_cmds[] = {
  24.     "USE",
  25.     "UNUSE",
  26.     "CLOCK",
  27.     "LPT",
  28.     "QUEUE",
  29.       };    
  30.       
  31. #define NUM_LPT_CMDS 4
  32. char *lpt_cmds[] = {
  33.      "TIMEOUT",
  34.      "COMBINE",
  35.      "FLUSH",
  36.      "SEPARATE"
  37.       };          
  38.       
  39. #define NUM_QUEUE_CMDS 6     
  40.   char *queue_cmds[] = {
  41.       "START",
  42.       "HALT",
  43.       "STOP",
  44.       "PAUSE",
  45.       "SINGLE",
  46.       "RESTART"
  47.       };
  48.  
  49.   FLAGS flags = {
  50.    FALSE,
  51.    FALSE,
  52.    ""
  53.  };
  54.  
  55. /* error ********************************************************************
  56.  
  57. *****************************************************************************/
  58. void error(code,message)
  59.   int code;
  60.   char *message;
  61. {
  62.   char *ptr;
  63.   
  64.   if (flags.suppress) return;
  65.   
  66.   if (code) {
  67.     ptr = get_error_text(code);
  68.     puts(ptr);
  69.   }
  70.   else puts(message);
  71. }
  72.  
  73. /* find_str ********************************************************************
  74. Returns -1 if target string not found
  75. *****************************************************************************/
  76. int find_str(string,array,n)
  77.   char *string,
  78.        *array[];
  79.    int n;
  80. {
  81.   int i,found;
  82.   
  83.   found = FALSE;
  84.   for (i = 0; i < n; i++ ) {
  85.     if (!strcmp(string,array[i])) {
  86.       found = TRUE;
  87.       break;
  88.     }
  89.   }
  90.   return((found) ? i : -1);
  91. }
  92.     
  93. /* net_use  ******************************************************************
  94.  
  95. *****************************************************************************/
  96. net_use(cmd)
  97.   char *cmd;
  98. {
  99.   char device[17],netpath[61],*ptr;
  100.   int type;
  101.   
  102.   type = 4;
  103.   
  104.   device[0] = netpath[0] = 0;
  105.   if (cmd != NULL) strcpy(device,cmd);
  106.  
  107.   if (strlen(device) > 2) {
  108.     if (!strncmp("LPT",device,3)) type = 3;
  109.     if (!strncmp("PRN",device,3)) type = 3;
  110.   }
  111.   
  112.   ptr = strtok(NULL," ");
  113.   if (ptr != NULL) strcpy(netpath,ptr);
  114.  
  115.   return(redirect_device(device,netpath,type));
  116. }
  117.  
  118. /* net_unuse  ****************************************************************
  119.  
  120. *****************************************************************************/
  121. net_unuse(cmd)
  122.   char *cmd;
  123. {
  124.   char device[17];
  125.  
  126.   device[0] = 0;
  127.   if (cmd != NULL) strcpy(device,cmd);
  128.  
  129.   return(cancel_redirection(device));
  130. }
  131.  
  132. /* net_clock ****************************************************************
  133.  
  134. *****************************************************************************/
  135. net_clock(cmd)
  136.   char *cmd;
  137. {
  138.  set_clock(cmd);
  139. }
  140.  
  141. /* net_lpt ******************************************************************
  142.  
  143. *****************************************************************************/
  144. net_lpt(cmd)
  145.   char *cmd;
  146. {
  147.   char *ptr;
  148.   int cmd_no,time,ret_code;
  149.   
  150.   ret_code = 0;
  151.   cmd_no = find_str(cmd,lpt_cmds,NUM_LPT_CMDS);
  152.   if (cmd_no >= 0) {
  153.     ptr = strtok(NULL," ");
  154.     switch (cmd_no) {
  155.       case 0:  /* timeout */
  156.         time = atoi(ptr);
  157.         ret_code = lpt_timeout(time);
  158.         break;
  159.       case 1:  /* combine */
  160.         set_lpt_mode(0);
  161.         break;
  162.       case 2:  /* flush */
  163.         flush_lpt();
  164.         break;
  165.       case 3:  /* separate */
  166.         set_lpt_mode(1);
  167.         break;
  168.     }      
  169.   }
  170.   else {
  171.     error(FALSE,"Invalid NET LPT command");
  172.     ret_code = -1;
  173.   }
  174.   return(ret_code);  
  175. }
  176.  
  177. /* net_queue ****************************************************************
  178.  
  179. *****************************************************************************/
  180. net_queue(cmd)
  181.   char *cmd;
  182. {
  183.   char *ptr;
  184.   int cmd_no,time,ret_code;
  185.   
  186.   ret_code = 0;
  187.   cmd_no = find_str(cmd,queue_cmds,NUM_QUEUE_CMDS);
  188.   if (cmd_no >= 0) {
  189.     ptr = strtok(NULL," ");
  190.     queue_ctl(cmd_no,ptr);
  191.   }
  192.   else {
  193.     error(FALSE,"Invalid NET QUEUE command");
  194.     ret_code = -1;
  195.   }
  196.   return(ret_code);  
  197. }
  198.  
  199. /* options */
  200. #define NUM_OPTIONS 3
  201. char *options[NUM_OPTIONS] = {
  202.     "STOP",
  203.     "SUPPRESS",
  204.     "HELP"
  205.   };
  206.  
  207. /* process_option ********************************************************************
  208.  
  209. *****************************************************************************/
  210. void process_option(string,flags)
  211.   char *string;
  212.   FLAGS *flags;
  213. {
  214.   char *ptr;
  215.   int i; 
  216.   
  217.   ptr = strtok(string,"=:");
  218.   
  219.   for (i = 0; i < NUM_OPTIONS; i++) {
  220.     if (!strcmpi(ptr,options[i])) break;
  221.   }
  222.   
  223.   if (i >= NUM_OPTIONS) {
  224.     printf("Whoops! %s isn't a valid command line option.\n",ptr);  
  225.     return;
  226.   }
  227.  
  228.   ptr = strtok(NULL," =");
  229.   
  230.   switch (i)  {
  231.     case 0:   /* stop on any error */
  232.       flags->stop = TRUE;
  233.       break;
  234.     case 1:   /* suppress error messages */
  235.       flags->suppress = TRUE;
  236.       break;
  237.     case 2:   /* help */
  238.       puts("FASTNET utility for LANtastic -- Copyright 1989 by SoftMagic, Inc.");
  239.       puts("All rights reserved.  LANtastic is a trademark of Artisoft, Inc.\n");
  240.       puts("Usage: FASTNET <file name> [/OPTIONS]");
  241.       puts("FASTNET quickly processes entire files of the most commonly used");
  242.       puts("NET commands. Commands that FASTNET does not recognize will be");
  243.       puts("passed to your normal command interpreter.\n");
  244.       puts("Available options are:");
  245.       puts("/STOP         - stop on any error condition");
  246.       puts("/SUPPRESS     - suppress all error messages");
  247.       puts("/HELP         - display this documentation");
  248.       exit(0);
  249.       break;
  250.   }
  251. }
  252.  
  253. /* scan_command_line ********************************************************************
  254.  
  255. *****************************************************************************/
  256. scan_command_line(argc,argv,flags)
  257.   int argc;
  258.   char *argv[];
  259.   FLAGS *flags;
  260. {
  261.   int i,state;
  262.   state=0;
  263.   
  264.   for (i = 1;i < argc; i++) {
  265.     strupr(argv[i]);
  266.     if (argv[i][0] == '/') {
  267.       process_option(&argv[i][1],flags);
  268.       continue;
  269.     }
  270.     switch (state++) {
  271.       case 0:    /* first valid arg */
  272.         strcpy(flags->fname,argv[i]);
  273.  
  274. /* expand fname to ".BAT" if no extension is given */
  275.         if (strchr(flags->fname,'.') == NULL) strcat(flags->fname,".BAT");
  276.         break;
  277.       default:
  278.         error(FALSE,"Extra command line argument ignored.");
  279.         break;  
  280.     }
  281.   }
  282. }
  283.  
  284. /* do_net_cmd ********************************************************************
  285.  
  286. *****************************************************************************/
  287. do_net_cmd(cmd)
  288.   char *cmd;
  289. {
  290.   int lastchar,cmd_no,ret_code;
  291.   char *ptr,cmd_cpy[81];
  292.   
  293.   ret_code = 0;
  294.   lastchar = strlen(cmd) - 1;
  295.   if (cmd[lastchar] == '\n') cmd[lastchar] = 0;
  296.   strupr(cmd);
  297.   strcpy(cmd_cpy,cmd);
  298.  
  299. /* see if we've got a net command or some other batch command */  
  300.   ptr = strtok(cmd," ");
  301.   if (!strcmp(ptr,"NET")) {
  302.     ptr = strtok(NULL," ");
  303.     cmd_no = find_str(ptr,net_cmds,NUM_NET_CMDS);
  304.     if (cmd_no >= 0) {
  305.       ptr = strtok(NULL," ");
  306.       switch (cmd_no) {
  307.         case 0:       /* use */
  308.           ret_code = net_use(ptr);
  309.           break;
  310.         case 1:       /* unuse */
  311.           ret_code = net_unuse(ptr);
  312.           break;
  313.         case 2:       /* clock */
  314.           net_clock(ptr);
  315.           break;
  316.         case 3:       /* lpt */
  317.           net_lpt(ptr);
  318.           break;
  319.         case 4:       /* queue */
  320.           net_queue(ptr);
  321.           break;
  322.       }
  323.     } else system(cmd_cpy);
  324.   } else system(cmd_cpy);
  325.   return(ret_code);
  326. }
  327.  
  328. /* main ********************************************************************
  329.  
  330. *****************************************************************************/
  331. int main(argc,argv)
  332.   int argc;
  333.   char *argv[];
  334. {
  335.   char buffer[1024];
  336.   FILE *cmdfile;
  337.   char cmd[81];
  338.   int ret_code;
  339.  
  340. #ifdef SHAREWARE
  341.   puts("FASTNET utility for LANtastic -- Copyright 1989 by SoftMagic, Inc.");
  342.   puts("All rights reserved.  Thanks for trying this unregistered Shareware edition!\n");
  343. #endif  
  344.  
  345.   scan_command_line(argc,argv,&flags);  
  346.   
  347.   if (!nos_present()) {
  348.     error(FALSE,"LANtastic is not currently running.");
  349.     return(-1);
  350.   }
  351.  
  352.   cmdfile = fopen(flags.fname,"rt");
  353.   if (cmdfile != NULL) {
  354.     setvbuf(cmdfile,buffer,_IOFBF,sizeof(buffer));
  355.     fgets(cmd,80,cmdfile);
  356.     while (!feof(cmdfile)) {
  357.       ret_code = do_net_cmd(cmd);
  358.       if (ret_code) {
  359.         error(ret_code,NULL);
  360.         if (flags.stop) break;
  361.       }
  362.       fgets(cmd,80,cmdfile);
  363.     }
  364.     fclose(cmdfile);
  365.   }
  366.   else {
  367.     sprintf(buffer,
  368.     "Sorry, I can't open the NET command file. (%s)\n",flags.fname);
  369.     error(FALSE,buffer);
  370.   }
  371.   return(ret_code);
  372. }